/**
 * 名称：创建体剖切
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：
 * 状态：
 * 网址：
 * 负责人：
 */
function createSection() {
  deleteHandlerFu()
  ClippingBox()
  ClippingBox.prototype.set3DTileset(globalTilesetArr[0])
  ClippingBox.prototype.setTarget(globalTranslationArr[0])
  ClippingBox.prototype.open()
}

/**
 * 名称：销毁剖切剖切
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：
 * 状态：
 * 网址：
 * 负责人：
 */
function deleteSection() {
  ClippingBox.prototype.close()
}

/**
 * 名称：剖面框
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：
 * 状态：
 * 网址：
 * 负责人：
 */
function ClippingBox() {
  // 鼠标移动事件
  clippingHandler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas)
  clippingHandler.setInputAction((e) => {
    console.log('鼠标移动了')
    if(flags.opened === true) {
      const pickedObject = viewer.scene.pick(e.endPosition)
      if(Cesium.defined(pickedObject) && Cesium.defined(pickedObject.id) && Cesium.defined(pickedObject.id.box)) {
        if(clippingEntityArray.length > 0) {
          clippingEntityArray[0].box.outlineColor = colors[1]
        }
      } else {
        if(clippingEntityArray.length > 0) {
          clippingEntityArray[0].box.outlineColor = flags.selected ? colors[2] : colors[0]
        }
      }
    }
  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE)

  // 鼠标点击事件
  clippingHandler.setInputAction((e) => {
    console.log('鼠标点击了')
    if(flags.opened === true) {
      // 删除锚点
      for(let i = 0; i < anchorEntityArray.length; i++) {
        viewer.entities.remove(anchorEntityArray[i])
      }
      anchorEntityArray = []

      const pickedObject = viewer.scene.pick(e.position)
      if(Cesium.defined(pickedObject) && Cesium.defined(pickedObject.id) && Cesium.defined(pickedObject.id.box)) {
        if(clippingEntityArray.length > 0) {
          clippingEntityArray[0].box.outlineColor = colors[2]
          flags.selected = true
        }

        // 重新计算锚点
        for(let i = 0; i < clipdata.centers.length; i++) {
          const anchorEntity = addPoint(viewer, clipdata.centers[i], directions[i])
          anchorEntityArray.push(anchorEntity)
        }
      } else if(flags.selected) {
        flags.selected = false
        if(clippingEntityArray.length > 0) {
          clippingEntityArray[0].box.outlineColor = colors[0]
        }
      }
    }
  }, Cesium.ScreenSpaceEventType.LEFT_CLICK)

  // 是否是锚点
  function isAnchor(pickedObject) {
    return pickedObject && pickedObject.id && pickedObject.id.direction && directions.indexOf(pickedObject.id.direction) !== -1
  }

  // 同步当前锚点（处理前后左右）
  function updateFBLRAnchor(dragedAnchor, index, pickPosition) {
    // 计算投影向量
    const translation = new Cesium.Cartesian3()
    if(prevPickPosition) {
      Cesium.Cartesian3.subtract(pickPosition, prevPickPosition, translation)
      Cesium.Cartesian3.projectVector(translation, clipdata.normals[index], translation)

      // 计算新的中心点并同步锚点
      const position = new Cesium.Cartesian3()
      Cesium.Cartesian3.add(clipdata.centers[index], translation, position)
      clipdata.centers[index] = position.clone()
      dragedAnchor.id.position = position.clone()
    }
    prevPickPosition = pickPosition
    return translation
  }

  // 同步当前锚点(处理上下)
  function updateTBAnchor(dragedAnchor, index, startPosition, endPosition) {
    // 计算投影向量
    const v = Cesium.Cartesian2.subtract(startPosition, endPosition, new Cesium.Cartesian2())
    const delta = Math.abs(v.x) > Math.abs(v.y) ? v.x : v.y

    const translation = new Cesium.Cartesian3()
    Cesium.Cartesian3.multiplyByScalar(Cesium.Cartesian3.UNIT_Z, delta, translation)
    Cesium.Cartesian3.projectVector(translation, clipdata.normals[index], translation)

    // 计算新的中心点并同步锚点
    const position = new Cesium.Cartesian3()
    Cesium.Cartesian3.add(clipdata.centers[index], translation, position)
    clipdata.centers[index] = position.clone()
    dragedAnchor.id.position = position.clone()

    return translation
  }

  // 同步相邻锚点
  function updateAdjoinAnchorEntity(index, originCenter, translation) {
    const position = new Cesium.Cartesian3()
    Cesium.Cartesian3.add(originCenter, translation, position)
    clipdata.centers[index] = position.clone()
    anchorEntityArray[index].position = position.clone()
    // 更新中心点
    updateOringin()
  }

  // 同步虚拟剖面框
  function updateClippingEntityPosition(clippingEntity, center, oppCenter) {
    const position = new Cesium.Cartesian3()
    Cesium.Cartesian3.midpoint(center, oppCenter, position)
    clippingEntity.position = position
  }

  // 更新真实剖面框
  function updateClippingPlanes(index, translation) {
    if(index < 0 || index > 5) return
    if(clippingTargetArray.length > 0) {
      const clippingPlanes = clippingTargetArray[0].clippingPlanes
      const plane = clippingPlanes.get(index)
      if(plane.direction === 'front' || plane.direction === 'behind') {
        const distance = Cesium.Cartesian3.distance(clipdata.centers[0], clipdata.centers[1])
        const plane1 = clippingPlanes.get(0)
        plane1.distance = distance / 2
        const plane2 = clippingPlanes.get(1)
        plane2.distance = distance / 2
      } else if(plane.direction === 'left' || plane.direction === 'right') {
        const distance = Cesium.Cartesian3.distance(clipdata.centers[2], clipdata.centers[3])
        const plane1 = clippingPlanes.get(2)
        plane1.distance = distance / 2
        const plane2 = clippingPlanes.get(3)
        plane2.distance = distance / 2
      } else if(plane.direction === 'top' || plane.direction === 'bottom') {
        const distance = Cesium.Cartesian3.distance(clipdata.centers[4], clipdata.centers[5])
        const plane1 = clippingPlanes.get(4)
        plane1.distance = distance / 2
        const plane2 = clippingPlanes.get(5)
        plane2.distance = distance / 2
      }
      // 同步真实剖面框
      const m3 = new Cesium.Matrix3()
      Cesium.Matrix4.getMatrix3(clippingTargetArray[0].root.transform, m3)
      Cesium.Matrix3.inverse(m3, m3)
      const vector = Cesium.Matrix3.multiplyByVector(m3, translation, new Cesium.Cartesian3())
      const m4 = new Cesium.Matrix4()
      Cesium.Matrix4.fromTranslation(vector, m4)
      Cesium.Matrix4.multiply(clippingPlanes.modelMatrix, m4, m4)
      clippingPlanes.modelMatrix = m4
    }
  }

  // 拖拽锚点，缩放剖面框
  viewer.screenSpaceEventHandler.setInputAction((e) => {
    const pickedObject = viewer.scene.pick(e.position)
    if(isAnchor(pickedObject)) {
      leftDownFlag = true
      dragedAnchor = pickedObject
      viewer.scene.screenSpaceCameraController.enableInputs = false
    }
  }, Cesium.ScreenSpaceEventType.LEFT_DOWN)
  viewer.screenSpaceEventHandler.setInputAction((e) => {
    viewer.scene.screenSpaceCameraController.enableInputs = true

    leftDownFlag = false
    dragedAnchor = null
    prevPickPosition = null
  }, Cesium.ScreenSpaceEventType.LEFT_UP)
  viewer.screenSpaceEventHandler.setInputAction((e) => {
    if(leftDownFlag === true && dragedAnchor != null) {
      const ray = viewer.camera.getPickRay(e.endPosition)
      const pickPosition = viewer.scene.globe.pick(ray, viewer.scene)
      if(pickPosition && clipdata.centers.length === 6 && clipdata.normals.length === 6 && clippingEntityArray.length > 0) {
        // 计算锚点索引
        const index = directions.indexOf(dragedAnchor.id.direction)
        if(dragedAnchor.id.direction === 'front' || dragedAnchor.id.direction === 'behind') {
          const translation = updateFBLRAnchor(dragedAnchor, index, pickPosition)
          // 同步和中心相邻的点：前后左右上下中的左右上下，同时同步锚点
          Cesium.Cartesian3.divideByScalar(translation, 2, translation)
          updateAdjoinAnchorEntity(2, clipdata.centers[2], translation)
          updateAdjoinAnchorEntity(3, clipdata.centers[3], translation)
          updateAdjoinAnchorEntity(4, clipdata.centers[4], translation)
          updateAdjoinAnchorEntity(5, clipdata.centers[5], translation)
          // 同步虚拟剖面框
          updateClippingEntityPosition(clippingEntityArray[0], clipdata.centers[0], clipdata.centers[1])
          // 同步真实剖面框
          updateClippingPlanes(index, translation)
        } else if(dragedAnchor.id.direction === 'left' || dragedAnchor.id.direction === 'right') {
          const translation = updateFBLRAnchor(dragedAnchor, index, pickPosition)
          // 同步和中心相邻的点：前后左右上下中的前后上下，同时同步锚点
          Cesium.Cartesian3.divideByScalar(translation, 2, translation)
          updateAdjoinAnchorEntity(0, clipdata.centers[0], translation)
          updateAdjoinAnchorEntity(1, clipdata.centers[1], translation)
          updateAdjoinAnchorEntity(4, clipdata.centers[4], translation)
          updateAdjoinAnchorEntity(5, clipdata.centers[5], translation)
          // 同步虚拟剖面框
          updateClippingEntityPosition(clippingEntityArray[0], clipdata.centers[2], clipdata.centers[3])
          // 同步真实剖面框
          updateClippingPlanes(index, translation)
        } else if(dragedAnchor.id.direction === 'top' || dragedAnchor.id.direction === 'bottom') {
          const translation = updateTBAnchor(dragedAnchor, index, e.startPosition, e.endPosition)
          // 同步和中心相邻的点：前后左右上下中的前后左右，同时同步锚点
          Cesium.Cartesian3.divideByScalar(translation, 2, translation)
          updateAdjoinAnchorEntity(0, clipdata.centers[0], translation)
          updateAdjoinAnchorEntity(1, clipdata.centers[1], translation)
          updateAdjoinAnchorEntity(2, clipdata.centers[2], translation)
          updateAdjoinAnchorEntity(3, clipdata.centers[3], translation)
          // 同步虚拟剖面框
          updateClippingEntityPosition(clippingEntityArray[0], clipdata.centers[4], clipdata.centers[5])
          // 同步真实剖面框
          updateClippingPlanes(index, translation)
        }
      }
    }
  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
}

/**
 * 名称：剖切是否开启
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：
 * 状态：
 * 网址：
 * 负责人：
 */
ClippingBox.prototype.isOpened = function() {
  return flags.opened
}

/**
 * 名称：开启剖切
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：
 * 状态：
 * 网址：
 * 负责人：
 */
ClippingBox.prototype.open = function() {
  console.log('一开始就执行')
  if(flags.opened === false) {
    flags.opened = true
  }
}

/**
 * 名称：关闭剖切
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：
 * 状态：
 * 网址：
 * 负责人：
 */
ClippingBox.prototype.close = function() {
  if(flags.opened === true) {
    flags.opened = false
    flags.selected = false
  }

  // 删除锚点
  for(let i = 0; i < anchorEntityArray.length; i++) {
    viewer.entities.remove(anchorEntityArray[i])
  }
  anchorEntityArray = []

  // 删除剖面框
  if(clippingEntityArray.length > 0) {
    viewer.entities.remove(clippingEntityArray[0])
    clippingEntityArray = []
  }

  // 清除目标对象
  if(clippingTargetArray.length > 0) {
    clippingTargetArray[0].clippingPlanes.enabled = false
    clippingTargetArray = []
  }

  // 清除data
  clipdata.centers = []
  clipdata.normals = []
}

/**
 * 名称：设置剖切对象
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：target
 * 状态：
 * 网址：
 * 负责人：
 */
ClippingBox.prototype.setTarget = function(target) {
  if(!flags.opened) return
  if(clippingTargetArray.length > 0 && clippingTargetArray[0] === target) return

  if(target instanceof Cesium.Cesium3DTileset) {
    ClippingBox.prototype.set3DTileset(target)
  }
}

/**
 * 名称：设置剖切对象
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：target
 * 状态：
 * 网址：
 * 负责人：
 */
ClippingBox.prototype.set3DTileset = function(tileset) {
  clippingTargetArray.push(tileset)
  tileset.readyPromise.then(() => {
    tileset.clippingPlanes = createClippingPlanes()

    const boundingSphere = tileset.boundingSphere
    const center = boundingSphere.center
    const radius = boundingSphere.radius

    // 计算剖面框中心位置
    clipdata.center = center.clone()
    const cartCenter = Cesium.Cartographic.fromCartesian(clipdata.center)

    // 计算剖面框旋转
    const m3 = Cesium.Matrix4.getMatrix3(tileset.root.transform, new Cesium.Matrix3())
    const quaternion = Cesium.Quaternion.fromRotationMatrix(m3, new Cesium.Quaternion())

    const clippingPlanes = tileset.clippingPlanes
    for(let i = 0; i < clippingPlanes.length; ++i) {
      const plane = clippingPlanes.get(i)
      plane.distance = radius / 2.0

      if(plane.direction === 'front' || plane.direction === 'behind' || plane.direction === 'left' || plane.direction === 'right') {
        // 先将平面向量于模型矩阵对齐
        const hpr = ClippingBox.quaternionToHeadingPitchRoll(clipdata.center, quaternion)
        const m = Cesium.Matrix3.fromHeadingPitchRoll(hpr, new Cesium.Matrix3())
        const normal = Cesium.Matrix3.multiplyByVector(m, plane.normal, new Cesium.Cartesian3())
        // 参照中心点计算投影点
        const localCartesian3 = Cesium.Cartesian3.multiplyByScalar(normal, plane.distance, new Cesium.Cartesian3())
        const tangentPlane = new Cesium.EllipsoidTangentPlane(clipdata.center)
        const projectCartesian3 = tangentPlane.projectPointOntoEllipsoid(localCartesian3)
        const projectCart = Cesium.Cartographic.fromCartesian(projectCartesian3)
        const anchorCenter = new Cesium.Cartographic(projectCart.longitude, projectCart.latitude, cartCenter.height)
        clipdata.centers.push(Cesium.Cartographic.toCartesian(anchorCenter))
      } else if(plane.direction === 'top' || plane.direction === 'bottom') {
        const offset = Cesium.Cartesian3.multiplyByScalar(plane.normal, plane.distance, new Cesium.Cartesian3())
        const anchorCenter = new Cesium.Cartographic(cartCenter.longitude, cartCenter.latitude, cartCenter.height + offset.z)
        clipdata.centers.push(Cesium.Cartographic.toCartesian(anchorCenter))
      }
    }

    // 计算法向量
    function normalize(startPosition, endPosition) {
      const normal = new Cesium.Cartesian3()
      Cesium.Cartesian3.subtract(startPosition, endPosition, normal)
      Cesium.Cartesian3.normalize(normal, normal)
      return normal
    }

    // 计算法向量
    clipdata.normals.push(normalize(clipdata.centers[0], clipdata.centers[1]))
    clipdata.normals.push(normalize(clipdata.centers[1], clipdata.centers[0]))
    clipdata.normals.push(normalize(clipdata.centers[2], clipdata.centers[3]))
    clipdata.normals.push(normalize(clipdata.centers[3], clipdata.centers[2]))
    clipdata.normals.push(normalize(clipdata.centers[4], clipdata.centers[5]))
    clipdata.normals.push(normalize(clipdata.centers[5], clipdata.centers[4]))

    // 更新中心点
    updateOringin()

    const clippingEntity = viewer.entities.add({
      id: 'ClippingEntity',
      position: new Cesium.CallbackProperty(() => {
        return clipdata.center
      }, false),
      orientation: quaternion,
      box: {
        dimensions: new Cesium.CallbackProperty(updateDimensions(), false),
        material: Cesium.Color.RED.withAlpha(0),
        outline: true,
        outlineColor: Cesium.Color.WHITE
      }
    })
    clippingEntityArray.push(clippingEntity)

    // 移动真实剖面框（真实剖面框是根据transform变换的）
    const transformCenter = Cesium.Matrix4.getTranslation(tileset.root.transform, new Cesium.Cartesian3())
    const translation = new Cesium.Cartesian3()
    Cesium.Cartesian3.subtract(clipdata.center, transformCenter, translation)
    Cesium.Matrix3.inverse(m3, m3)
    Cesium.Matrix3.multiplyByVector(m3, translation, translation)
    const m4 = new Cesium.Matrix4()
    Cesium.Matrix4.fromTranslation(translation, m4)
    Cesium.Matrix4.multiply(clippingPlanes.modelMatrix, m4, m4)
    clippingPlanes.modelMatrix = m4
  })
}

/**
 * 名称：设置剖切对象
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：target
 * 状态：
 * 网址：
 * 负责人：
 */
ClippingBox.quaternionToHeadingPitchRoll = function(position, quaternion) {
  const m3 = Cesium.Matrix3.fromQuaternion(quaternion)
  const m4 = Cesium.Matrix4.fromRotationTranslation(m3, position)
  return Cesium.Transforms.fixedFrameToHeadingPitchRoll(m4)
}

/**
 * 名称：中心点计算
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：target
 * 状态：
 * 网址：
 * 负责人：
 */
function updateOringin() {
  if(clipdata.centers.length === 6) {
    // 前后的中点
    const fbMid = Cesium.Cartesian3.midpoint(clipdata.centers[0], clipdata.centers[1], new Cesium.Cartesian3())
    // 左右的中点
    const lrMid = Cesium.Cartesian3.midpoint(clipdata.centers[2], clipdata.centers[3], new Cesium.Cartesian3())
    // 计算前后左右的中点（数据准确，只使用前后、左右或者上下均可）
    clipdata.center = Cesium.Cartesian3.midpoint(fbMid, lrMid, new Cesium.Cartesian3())
  }
}

/**
 * 名称：动态更新剖面框大小
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：target
 * 状态：
 * 网址：
 * 负责人：
 */
function updateDimensions() {
  return () => {
    if(clipdata.centers.length === 6) {
      return new Cesium.Cartesian3(
        Cesium.Cartesian3.distance(clipdata.centers[2], clipdata.centers[3]),
        Cesium.Cartesian3.distance(clipdata.centers[0], clipdata.centers[1]),
        Cesium.Cartesian3.distance(clipdata.centers[4], clipdata.centers[5])
      )
    }
  }
}

/**
 * 名称：模拟锚点
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：target
 * 状态：
 * 网址：
 * 负责人：
 */
function addPoint(viewer, position, direction) {
  return viewer.entities.add({
    position: position,
    direction: direction,
    name: direction,
    point: {
      pixelSize: 10,
      color: Cesium.Color.RED,
      outlineColor: Cesium.Color.YELLOW,
      outlineWidth: 3.82,
      verticalOrigin: Cesium.VerticalOrigin.CENTER,
      distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, Number.MAX_VALUE),
      disableDepthTestDistance: Number.MAX_VALUE
    }
  })
}

/**
 * 名称：创建剖面
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：target
 * 状态：
 * 网址：
 * 负责人：
 */
function createClippingPlanes() {
  // ['front', 'behind', 'left', 'right', 'top', 'bottom'];
  const clippingPlanes = new Cesium.ClippingPlaneCollection({
    planes: [
      // new Cesium.ClippingPlane(new Cesium.Cartesian3(0, -1, 0), 0), // 前
      // new Cesium.ClippingPlane(new Cesium.Cartesian3(0, 1, 0), 0), // 后
      // new Cesium.ClippingPlane(new Cesium.Cartesian3(1, 0, 0), 0), // 左
      // new Cesium.ClippingPlane(new Cesium.Cartesian3(-1, 0, 0), 0), // 右
      // new Cesium.ClippingPlane(new Cesium.Cartesian3(0, 0, -1), 0), // 上
      // new Cesium.ClippingPlane(new Cesium.Cartesian3(0, 0, 1), 0), // 下

      new Cesium.ClippingPlane(new Cesium.Cartesian3(0, 1, 0), 0), // 前
      new Cesium.ClippingPlane(new Cesium.Cartesian3(0, -1, 0), 0), // 后
      new Cesium.ClippingPlane(new Cesium.Cartesian3(1, 0, 0), 0), // 左
      new Cesium.ClippingPlane(new Cesium.Cartesian3(-1, 0, 0), 0), // 右
      new Cesium.ClippingPlane(new Cesium.Cartesian3(0, 0, 1), 0), // 上
      new Cesium.ClippingPlane(new Cesium.Cartesian3(0, 0, -1), 0) // 下
    ],
    unionClippingRegions: true // true 才能多个切割
  })
  // 设定方向，以备后续拖拽使用
  const planes = clippingPlanes._planes
  for(let i = 0; i < clippingPlanes.length; ++i) {
    planes[i].direction = directions[i]
  }
  return clippingPlanes
}

/**
 * 名称：创建平剖
 * 作用：通过传入的类型创建对应的测量方式
 * 参数：height：高度
 * 状态：
 * 网址：
 * 负责人：杨世林
 */
function createAFlatSection(height) {
  // 退出剖切
  exitSlicing()
  console.log('开始剖切')
  // 定义一个ClippingPlaneCollection类，用来存储裁剪面
  clippingPlanes = new Cesium.ClippingPlaneCollection({
    planes: [
      // ClippingPlane对象数组集合
      new Cesium.ClippingPlane(new Cesium.Cartesian3(0.0, 0.0, -1.0), // 法线方向
        0.0  // 原点到平面的最短距离，设置0就好
      )
    ],
    // edgeColor: Cesium.Color.RED,
    edgeWidth: 1.0, // 模型被裁切部分的截面线宽
    unionClippingRegions: true //true 才能多个切割
  })
  tileset.clippingPlanes = clippingPlanes
  // tileset.debugShowBoundingVolume = viewModel.debugBoundingVolumesEnabled;
  return tileset.readyPromise.then(function() {
    var boundingSphere = tileset.boundingSphere
    var radius = boundingSphere.radius
    for(var i = 0; i < clippingPlanes.length; ++i) {
      var plane = clippingPlanes.get(i)
      plane.distance = height
    }
    return tileset
  }).catch(function(error) {
    console.log(error)
  })
}

/**
 * 名称：退出剖切
 * 作用：点击直接退出剖切操作
 * 参数：height：高度
 * 状态：
 * 网址：
 * 负责人：杨世林
 */
function exitSlicing() {
  console.log('退出平剖操作')
  // 退出剖切
  tileset.clippingPlanes = new Cesium.ClippingPlaneCollection()
  // 删除箭头
  viewer.entities.removeById('cutArrow')
}

/**
 * 名称：创建平剖
 * 作用：点击模型进行平剖设置
 * 参数：height：高度
 * 状态：
 * 网址：
 * 负责人：杨世林
 */
// 记录剖切状态
let cuttingStatus = true

function addSection() {
  if(cuttingStatus) {
    cuttingStatus = false
    // 开始剖切
    // 删除鼠标操作
    deleteHandlerFu()
    // 左键单击开始画线
    handler.setInputAction(function(click) {
      // 计算点击高度
      let positionOne = positionAssembly(click.position)
      if(positionOne === undefined || positionOne === false) {
        return
      }
      let positionTwo = { x: positionOne.x, y: positionOne.y, z: positionOne.z + 10 }
      let pointOne = Cesium.Cartographic.fromCartesian(positionOne)
      let pointTwo = returnHeightPosition(positionOne, positionTwo)
      createAFlatSection(pointOne.height)
      drawArrowLines([positionOne, pointTwo])
      // 注销鼠标操作
      deleteHandlerFu()
      // 创建拖拽
      sectionSolidDrag()
    }, Cesium.ScreenSpaceEventType.LEFT_CLICK)
  } else {
    // 退出剖切
    exitSlicing()
  }
}

/**
 * 名称：绘制箭头线
 * 作用：点击一点，绘制一个箭头线
 * 参数：position坐标数据：[position1, position2]
 * 状态：
 * 网址：
 * 负责人：杨世林
 */
function drawArrowLines(position) {
  console.log('开始绘制箭头：', position)
  var redLine = viewer.entities.add({
    // 贴在地面上 两点之间的直线距离
    name: 'line',
    id: 'cutArrow',
    polyline: {
      positions: position,
      width: 10,
      // 不带箭头的线
      // material: Cesium.Color.RED,
      // 是否紧贴地面
      //clampToGround: true,
      // 带箭头的线
      material: new Cesium.PolylineArrowMaterialProperty(
        Cesium.Color.RED
      )
    }
  })
}

/**
 * 名称：剖切拖拽实体执行方法
 * 说明：通过点击实体点获取实体信息然后进行拖动
 * 参数：
 * 状态：已完成
 * 负责人：/
 * 网址：https://blog.csdn.net/qq_40323256/article/details/128391607
 */
function sectionSolidDrag() {
  console.log('开始移动')
  deleteHandlerFu()
  handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas)
  getSectionDragData()
  sectionMouseUp()
}

/**
 * 名称：实体点信息获取
 * 说明：通过点击获取实体信息，并锁定相机
 * 参数：
 * 状态：已完成
 * 负责人：/
 * 网址：https://blog.csdn.net/qq_40323256/article/details/128391607
 */
function getSectionDragData() {
  handler.setInputAction(e => {
    let picks = viewer.scene.pick(e.position)
    console.log('查看信息picks------>：', picks)
    if(Cesium.defined(picks) && (picks.id.id)) {
      console.log('查看拖拽id信息：', picks.id.id)
      dragPointLpick = picks
      dragPointLeftDownFlag = true
      viewer.scene.screenSpaceCameraController.enableRotate = false//锁定相机
      if(picks.id.id === 'cutArrow') {
        console.log('开始改变平剖数据：')
        // 剖切数据改变操作
        // 1.改变第一点的高度根据拖拽的点来进行高度的添加
        // 触摸事件
        unpdateFlatSection(picks.id.id)
      }
    }
  }, Cesium.ScreenSpaceEventType.LEFT_DOWN)
}

/**
 * 名称：鼠标抬起事件
 * 说明：拖拽实体点解锁相机
 * 参数：
 * 状态：已完成
 * 负责人：/
 * 网址：https://blog.csdn.net/qq_40323256/article/details/128391607
 */
function sectionMouseUp() {
  handler.setInputAction(e => {
    if(dragPointLeftDownFlag === true && dragPointLpick != null) {
      dragPointLeftDownFlag = false
      viewer.scene.screenSpaceCameraController.enableRotate = true//解锁相机
      SectionDestroyMove()
    }
  }, Cesium.ScreenSpaceEventType.LEFT_UP)
}

/**
 * 名称：销毁移动事件
 * 说明：将拖拽事件进行销毁并进行颜色的操作
 * 参数：
 * 状态：已完成
 * 负责人：/
 * 网址：https://blog.csdn.net/qq_40323256/article/details/128391607
 */
function SectionDestroyMove() {
  handler.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE)
  if(recordMeasurementPoints) {
    recordMeasurementPoints.material = new Cesium.PolylineArrowMaterialProperty(
      Cesium.Color.RED
    )
    recordMeasurementPoints = null
  }
}

// 更改平剖数据
function unpdateFlatSection(id) {
  let height = null
  let realTimeHeight = null
  let pointOne2 = null
  handler.setInputAction(e => {
    let entitie = viewer.entities.getById(id)
    entitie.polyline.material = new Cesium.PolylineArrowMaterialProperty(
      Cesium.Color.YELLOW
    )
    // 当前点的位置高度计算
    console.log('查看当前数据信息：', e.endPosition)
    let positionOne = positionAssembly(e.endPosition)
    if(positionOne === undefined || positionOne === false) {
      return
    }
    // let positionTwo = {x:positionOne.x, y: positionOne.y, z: positionOne.z + 10}
    // 实时触摸的高度
    let pointOne = Cesium.Cartographic.fromCartesian(positionOne)
    realTimeHeight = pointOne.height
    let startDrop = entitie.polyline.positions._value[0]
    let endDrop = entitie.polyline.positions._value[1]
    // 当高度大于当前高度就进行+1，小于当前高度就-1
    let point1 = null
    let point2 = null
    if(height) {
      if(height < realTimeHeight) {
        console.log('下降', height, '----', realTimeHeight)
        // 小于当前高度就-1
        // 改变首尾两点高度
        point1 = returnHeightPosition(startDrop, { x: startDrop.x, y: startDrop.y, z: startDrop.z - 1 })
        pointOne2 = Cesium.Cartographic.fromCartesian({ x: startDrop.x, y: startDrop.y, z: startDrop.z - 1 })
        point2 = returnHeightPosition(endDrop, { x: endDrop.x, y: endDrop.y, z: endDrop.z - 1 })
        height = realTimeHeight
      } else {
        console.log('上升', height, '----', realTimeHeight)
        // 当高度大于当前高度就进行+1
        // 改变首尾两点高度
        point1 = returnHeightPosition(startDrop, { x: startDrop.x, y: startDrop.y, z: startDrop.z + 1 })
        point2 = returnHeightPosition(endDrop, { x: endDrop.x, y: endDrop.y, z: endDrop.z + 1 })
        height = realTimeHeight
        pointOne2 = Cesium.Cartographic.fromCartesian({ x: startDrop.x, y: startDrop.y, z: startDrop.z + 1 })
      }
      entitie.polyline.positions = [point1, point2]
    } else {
      height = pointOne.height
    }
    createAFlatSection(pointOne2.height)
    recordMeasurementPoints = entitie.polyline
  }, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
}
